home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 February / EnigmA AMIGA RUN 04 (1996)(G.R. Edizioni)(IT)[!][issue 1996-02][Skylink CD III].iso / earcd / comm2 / kms20src.lha / KMSC / datei.c < prev    next >
C/C++ Source or Header  |  1995-04-01  |  55KB  |  2,304 lines
  1. /**********************************
  2.  *              KMS               *
  3.  **********************************
  4.  *  ©1992 by BlackMagic Software  *
  5.  **********************************
  6.  *                                *
  7.  **********************************/
  8.  
  9. #include <KMS/KMS.h>
  10. #include <KMS/KMS_devlib.h>
  11.  
  12. Prototype LONG DirWork(STRPTR, STRPTR, UWORD);
  13. Prototype BOOL Exists(STRPTR);
  14. Prototype BOOL DirExists(STRPTR);
  15. Prototype BOOL SendFile(STRPTR, UWORD);
  16. Prototype VOID LogEntry(STRPTR);
  17. Prototype VOID SysMsg(UWORD);
  18. Prototype STRPTR GetSysMsgLine(STRPTR, STRPTR, UWORD);
  19. Prototype VOID TrimString(STRPTR);
  20. Prototype VOID SystemError(STRPTR, STRPTR);
  21. Prototype VOID FileError(STRPTR, STRPTR);
  22. Prototype BOOL Batch(STRPTR, UBYTE);
  23. Prototype BOOL BatchEdit(STRPTR);
  24. Prototype BOOL BatchDelete(STRPTR);
  25. Prototype BOOL BatchDir(VOID);
  26. Prototype BOOL AddSelEntry(UWORD);
  27. Prototype BOOL DelSelEntry(VOID);
  28. Prototype BOOL ListSelFile(VOID);
  29. Prototype BOOL ExecSelFile(UWORD);
  30. Prototype BOOL AddKillEntry(UWORD);
  31. Prototype BOOL DelKillEntry(VOID);
  32. Prototype BOOL ListKillFile(VOID);
  33. Prototype BOOL ExecKillFile(VOID);
  34. Prototype BOOL AddAliasEntry(UWORD);
  35. Prototype BOOL DelAliasEntry(VOID);
  36. Prototype BOOL ListAliasFile(VOID);
  37. Prototype VOID GetAlias(STRPTR, UWORD, UWORD);
  38. Prototype VOID WordWrap(STRPTR, UWORD, UWORD);
  39. Prototype BOOL LineEditor(STRPTR);
  40. Prototype LONG SystemCall(STRPTR);
  41. Prototype BOOL Copy(STRPTR, STRPTR, BOOL);
  42.  
  43. LONG IsInteractive(BPTR);
  44.  
  45. /*****************************
  46.  * Externe Globale Variablen *
  47.  *****************************/
  48.  
  49. extern struct KMSBase *KMSBase;
  50. extern struct LocalConfig *KMS_LC;
  51.  
  52. extern UMSAccount MyUMSAccount, SysUMSAccount;
  53.  
  54. extern TEXT PathString[];
  55.  
  56. extern BPTR OldInput;
  57.  
  58. extern UMSMsgNum Lastmsg;
  59.  
  60. extern STRPTR RFromName;
  61. extern STRPTR RFromAddr;
  62. extern STRPTR RCreationDate;
  63. extern STRPTR RSubject;
  64.  
  65. struct TagItem UMSCurrTags[6] =
  66.    {
  67.    {UMSTAG_RMsgNum, 0},
  68.    {UMSTAG_RFromName, &RFromName},
  69.    {UMSTAG_RFromAddr, &RFromAddr},
  70.    {UMSTAG_RCreationDate, &RCreationDate},
  71.    {UMSTAG_RSubject, &RSubject},
  72.    {TAG_DONE, 0}
  73.    };
  74.  
  75. extern STRPTR PPArg, PPArg2;
  76.  
  77. extern UBYTE ShutDown, Plop;
  78.  
  79. extern TEXT KMSTempDat[];
  80.  
  81. extern struct UserNode DummyUser;
  82.  
  83. /*************************************
  84.  * Directory-Scan                    *
  85.  *************************************
  86.  * I: Dirname, Flags                 *
  87.  * O: Size / -1 (Fehler)             *
  88.  *************************************/
  89.  
  90. /// "DirWork"
  91.  
  92. LONG DirWork(STRPTR dirname, STRPTR pattern, UWORD flag)
  93.    {
  94.    LONG more;
  95.    BPTR mylock;
  96.    struct ExAllData *eadata, *ead;
  97.    ULONG sum = 0;
  98.    TEXT buff[LEN_MAXLINE+1];
  99.    STRPTR pattdest = NULL;
  100.    UBYTE stop = 0;
  101.  
  102.    if (pattern)
  103.       {
  104.       pattdest = malloc(strlen(pattern) * 2 + 2);
  105.       if (pattdest)
  106.          ParsePatternNoCase(pattern, pattdest, strlen(pattern) * 2 + 2);
  107.       }
  108.  
  109.    eadata = (struct ExAllData *)AllocMem(LEN_EADATA, MEMF_CLEAR);
  110.    if (!eadata)
  111.       {
  112.       if (pattdest)
  113.          free(pattdest);
  114.  
  115.       SystemError("DirWork", "AllocMem");
  116.       return -1L;
  117.       }
  118.  
  119.    if (!(mylock = Lock(dirname, SHARED_LOCK)))
  120.       {
  121.       FreeMem(eadata, LEN_EADATA);
  122.       if (pattdest)
  123.          free(pattdest);
  124.  
  125.       SystemError("DirWork", "Lock");
  126.       return -1L;
  127.       }
  128.  
  129.    struct ExAllControl *eac = AllocDosObject(DOS_EXALLCONTROL, NULL);
  130.    if (!eac)
  131.       {
  132.       UnLock(mylock);
  133.       FreeMem(eadata, LEN_EADATA);
  134.       if (pattdest)
  135.          free(pattdest);
  136.  
  137.       SystemError("DirWork", "AllocDosObject");
  138.       return -1L;
  139.       }
  140.  
  141.    eac->eac_LastKey = 0;
  142.    eac->eac_MatchString = pattdest;
  143.    eac->eac_MatchFunc = NULL;
  144.    do {
  145.       more = ExAll(mylock, eadata, LEN_EADATA, ED_SIZE, eac);
  146.       /* If non-zero is returned, you MUST call ExAll again until
  147.          it returns FALSE. */
  148.  
  149.       if (more == DOSFALSE && IoErr() != ERROR_NO_MORE_ENTRIES)
  150.          break;
  151.       else if (eac->eac_Entries == 0)
  152.          continue;
  153.  
  154.       ead = eadata;
  155.       do {
  156.          sum += ead->ed_Size;
  157.  
  158.          if (!stop && (flag & DWF_LIST))
  159.             {
  160.             sprintf(buff, "%-30s %7ld\n", ead->ed_Name, ead->ed_Size);
  161.             stop = MsgPrint(buff, 0);
  162.             }
  163.  
  164.          ead = ead->ed_Next;
  165.          } while(ead);
  166.  
  167.       } while(more == DOSTRUE);
  168.  
  169.    FreeDosObject(DOS_EXALLCONTROL, eac);
  170.    UnLock(mylock);
  171.    FreeMem(eadata, LEN_EADATA);
  172.    if (pattdest)
  173.       free(pattdest);
  174.  
  175.    return sum;
  176.    }
  177.  
  178. ///
  179.  
  180. /*************************************
  181.  * Test, ob Directory existiert      *
  182.  *************************************
  183.  * I: Dirname                        *
  184.  * O: TRUE/FALSE                     *
  185.  *************************************/
  186.  
  187. /// "DirExists"
  188.  
  189. BOOL DirExists(STRPTR name)
  190.    {
  191.    BOOL error;
  192.    BPTR mylock;
  193.    struct FileInfoBlock *fileinfo = (struct FileInfoBlock *)AllocVec(sizeof(struct FileInfoBlock), MEMF_CLEAR);
  194.    if (!fileinfo)
  195.       return FALSE;
  196.  
  197.    if (fileinfo && (mylock = Lock(name, ACCESS_READ)))
  198.       {
  199.       if (Examine(mylock, fileinfo))
  200.          {
  201.          if (fileinfo->fib_DirEntryType <= 0) /* Not a directory */
  202.             error = TRUE;
  203.          else
  204.             error = FALSE;
  205.          }
  206.       else
  207.          error = TRUE;
  208.  
  209.       UnLock(mylock);
  210.       }
  211.    else
  212.       error = TRUE;
  213.  
  214.    FreeVec(fileinfo);
  215.  
  216.    if (error)
  217.       return FALSE;
  218.    else
  219.       return TRUE;
  220.    }
  221.  
  222. ///
  223.  
  224. /*************************************
  225.  * Test, ob Datei bzw. Dir existiert *
  226.  *************************************
  227.  * I: Dateiname                      *
  228.  * O: TRUE/FALSE                     *
  229.  *************************************/
  230.  
  231. /// "Exists"
  232.  
  233. BOOL Exists(STRPTR name)
  234.    {
  235.    BPTR lock;
  236.  
  237.    if (lock=Lock(name, ACCESS_READ))
  238.       {
  239.       UnLock(lock);
  240.       return TRUE;
  241.       }
  242.  
  243.    return FALSE;
  244.    }
  245.  
  246. ///
  247.  
  248. /********************************
  249.  * Datei senden                 *
  250.  ********************************
  251.  * I: Name, Flags               *
  252.  * O: ---                       *
  253.  ********************************/
  254.  
  255. /// "SendFile"
  256.  
  257. BOOL SendFile(STRPTR name, UWORD flag)
  258.    {
  259.    FILE *sendung;
  260.    BYTE more;
  261.    UBYTE linecount = 0;
  262.    UWORD lfflag;
  263.    BOOL weiter = TRUE, continuous = FALSE, newline = FALSE;
  264.    TEXT dosbuff[LEN_DOSPATH+1];
  265.    TEXT line[LEN_SENDFILE+1];
  266.  
  267.    if (strchr(name, '/') || strchr(name, ':'))
  268.       strcpy(dosbuff, name);
  269.    else
  270.       {
  271.       strcpy(dosbuff, KMSBase->TxtDir);
  272.       strcat(dosbuff, name);
  273.       }
  274.  
  275.    if (flag & SF_CHOOSEEXT)
  276.       {
  277.       if (KMS_LC->Session.CurrentUser->UserData.Flags & UF_EMU_ANSI)
  278.          strcat(dosbuff, ".ANSI");
  279.       else
  280.          strcat(dosbuff, ".TXT");
  281.  
  282.       if (!Exists(dosbuff))
  283.          {
  284.          if (strchr(name, '/') || strchr(name, ':'))
  285.             strcpy(dosbuff, name);
  286.          else
  287.             {
  288.             strcpy(dosbuff, KMSBase->TxtDir);
  289.             strcat(dosbuff, name);
  290.             }
  291.  
  292.          strcat(dosbuff, ".TXT");
  293.          }
  294.       }
  295.  
  296.    if (sendung = fopen(dosbuff, "r"))
  297.       {
  298.       while(weiter && fgets(line, sizeof(line), sendung))
  299.          {
  300.          /* LF am Zeilenende entfernen */
  301.  
  302.          if (line[strlen(line)-1] == '\n')
  303.             {
  304.             newline = TRUE;
  305.             line[strlen(line)-1] = '\0';
  306.             lfflag = 0;
  307.             }
  308.          else
  309.             {
  310.             newline = FALSE;
  311.             lfflag = PF_NOLF;
  312.             }
  313.  
  314.          /* Zeile senden */
  315.  
  316.          if (ParsePrint(line, PF_CTRLX|PF_CTRLC|lfflag))
  317.             weiter = FALSE;
  318.  
  319.          if (!continuous && newline && KMS_LC->Session.CurrentUser->UserData.PageLen)
  320.             {
  321.             linecount++;
  322.  
  323.             if (linecount + 1 == KMS_LC->Session.CurrentUser->UserData.PageLen)
  324.                {
  325.                linecount = 0;
  326.  
  327.                more = MoreRequest();
  328.                if (more < 0)
  329.                   continuous = TRUE;
  330.                else if (more == 0)
  331.                   weiter = FALSE;
  332.                }
  333.             }
  334.          }
  335.  
  336.       fclose(sendung);
  337.  
  338.       return TRUE;
  339.       }
  340.  
  341.    return FALSE;
  342.    }
  343.  
  344. ///
  345.  
  346. /********************************
  347.  * Logbuch-Eintrag              *
  348.  ********************************
  349.  * I: Text                      *
  350.  * O: ---                       *
  351.  ********************************/
  352.  
  353. /// "LogEntry"
  354.  
  355. VOID LogEntry(STRPTR text)
  356.    {
  357.    TEXT buff[LEN_MAXLINE+1];
  358.    TEXT outtext[LEN_LOGLINE+1];
  359.  
  360.    if (text)
  361.       {
  362.       StdStringParse(text, outtext, LEN_LOGLINE);
  363.       sprintf(buff, "LOGENTRY \"%s\"", outtext);
  364.       }
  365.    else
  366.       strcpy(buff, "LOGENTRY");
  367.  
  368.    sendRexxCmd(buff, NULL, NULL, NULL, NULL, "KMS");
  369.    }
  370.  
  371. ///
  372.  
  373. /********************************
  374.  * Systemmeldung                *
  375.  ********************************
  376.  * I: Msg-Nummer                *
  377.  * O: ---                       *
  378.  ********************************/
  379.  
  380. /// "SysMsg"
  381.  
  382. VOID SysMsg(UWORD msgnum)
  383.    {
  384.    STRPTR startpoint;
  385.    TEXT line[LEN_MAXLINE+1];
  386.    TEXT buff[LEN_MAXLINE+1];
  387.  
  388.    if (!msgnum || msgnum > MAXSYSMSG)
  389.       {
  390.       Print("INTERNAL ERROR: [SysMsg] Invalid msgnum", 0);
  391.       LogEntry("1INTERNAL ERROR: [SysMsg] Invalid msgnum");
  392.       return;
  393.       }
  394.  
  395.    if (KMSBase->SysMsgs)
  396.       {
  397.       startpoint = KMSBase->SysMsgs + KMSBase->SysMsgOffsets[msgnum-1];
  398.  
  399.       if (startpoint)
  400.          {
  401.          while((startpoint = GetSysMsgLine(startpoint, line, LEN_MAXLINE)) && *line != '@')
  402.             {
  403.             if (strlen(line))
  404.                {
  405.                if (strrchr("0123456789", *line))
  406.                   LogEntry(line);
  407.                else if (KMS_LC->Session.Echo)
  408.                   {
  409.                   if (line[strlen(line)-1] == '|')
  410.                      {
  411.                      line[strlen(line)-1] = '\0';
  412.                      ParsePrint(line, PF_NOLF|PF_NOBRK);
  413.                      }
  414.                   else if (line[strlen(line)-1] == '&')
  415.                      {
  416.                      TEXT fmt[LEN_NUMBER+3+1];
  417.  
  418.                      line[strlen(line)-1] = '\0';
  419.  
  420.                      sprintf(fmt, "%%-%ds", KMS_LC->Session.CurrentUser->UserData.LineLen);
  421.                      sprintf(buff, fmt, line);
  422.  
  423.                      ParsePrint(buff, 0);
  424.                      }
  425.                   else
  426.                      ParsePrint(line, 0);
  427.                   }
  428.                }
  429.             else if (KMS_LC->Session.Echo)
  430.                ParsePrint(line, 0);
  431.             }
  432.          }
  433.       else
  434.          {
  435.          Print("INTERNAL ERROR: [SysMsg] Invalid startpoint", 0);
  436.          LogEntry("1INTERNAL ERROR: [SysMsg] Invalid startpoint");
  437.          }
  438.       }
  439.    else
  440.       {
  441.       Print("INTERNAL ERROR: [SysMsg] Invalid SysMsgs", 0);
  442.       LogEntry("1INTERNAL ERROR: [SysMsg] Invalid SysMsgs");
  443.       }
  444.    }
  445.  
  446. ///
  447.  
  448. /*******************************************
  449.  * Zeile aus SysMsgList lesen              *
  450.  *******************************************
  451.  * I: StartPointer, ZielBuffer, Max. Länge *
  452.  * O: Neue Position in SysMsg-Datei        *
  453.  *******************************************/
  454.  
  455. /// "GetSysMsgLine"
  456.  
  457. STRPTR GetSysMsgLine(STRPTR startpoint, STRPTR buff, UWORD maxlen)
  458.    {
  459.    TEXT c = *(startpoint++);
  460.  
  461.    /* Zeile einlesen */
  462.  
  463.    maxlen++;
  464.    while(c != '\n' && c > 0 && --maxlen)
  465.       {
  466.       *(buff++) = c;
  467.       c = *(startpoint++);
  468.       }
  469.    *buff = '\0';
  470.  
  471.    /* Falls Zeile zu lang, Rest der Zeile ueberlesen */
  472.  
  473.    if (c != '\n')
  474.       while(c != '\n' && c > 0)
  475.          c = *(startpoint++);
  476.  
  477.    if (c == '\n')
  478.       return startpoint;
  479.    else
  480.       return NULL;
  481.    }
  482.  
  483. ///
  484.  
  485. /*****************************************
  486.  * Leerzeichen am Stringende abschneiden *
  487.  *****************************************
  488.  * I: String                             *
  489.  * O: ---                                *
  490.  *****************************************/
  491.  
  492. /// "TrimString"
  493.  
  494. VOID TrimString(STRPTR string)
  495.    {
  496.    WORD n;
  497.  
  498.    if (string && strlen(string))
  499.       {
  500.       n = strlen(string) - 1;
  501.       while(string[n] == ' ')
  502.          n--;
  503.       string[n+1] = '\0';
  504.       }
  505.    }
  506.  
  507. ///
  508.  
  509. /****************************
  510.  * Allgemeiner Systemfehler *
  511.  ****************************
  512.  * I: Fehler-Ort, Text      *
  513.  * O: ---                   *
  514.  ****************************/
  515.  
  516. /// "SystemError"
  517.  
  518. VOID SystemError(STRPTR loc, STRPTR text)
  519.    {
  520.    TEXT buff[LEN_LOGLINE+1];
  521.  
  522.    SysMsg(SYSEVENT);
  523.    SysMsg(SYSTEM_FAILURE);
  524.  
  525.    if (loc && text)
  526.       {
  527.       if (strlen(loc)+strlen(text)+15 <= LEN_LOGLINE)
  528.          sprintf(buff, "1SysError: [%s]: %s", loc, text);
  529.       else if (strlen(loc)+13 <= LEN_LOGLINE)
  530.          sprintf(buff, "1SysError: [%s]", loc);
  531.       else if (strlen(text)+11 <= LEN_LOGLINE)
  532.          sprintf(buff, "1SysError: %s", text);
  533.       else
  534.          sprintf(buff, "1SysError: [...] ...");
  535.       }
  536.    else
  537.       sprintf(buff, "1SysError: ???");
  538.  
  539.    LogEntry(buff);
  540.    Error(buff+1);
  541.  
  542.    if (MyUMSAccount)
  543.       {
  544.       if (UMSErrNum(MyUMSAccount))
  545.          {
  546.          strcpy(buff, "1UMSError: ");
  547.          strncat(buff, UMSErrTxt(MyUMSAccount), LEN_LOGLINE-strlen(buff));
  548.          buff[LEN_LOGLINE] = '\0';
  549.          LogEntry(buff);
  550.          Error(buff+1);
  551.          }
  552.       }
  553.    if (SysUMSAccount)
  554.       {
  555.       if (UMSErrNum(SysUMSAccount))
  556.          {
  557.          strcpy(buff, "1UMSError: ");
  558.          strncat(buff, UMSErrTxt(SysUMSAccount), LEN_LOGLINE-strlen(buff));
  559.          buff[LEN_LOGLINE] = '\0';
  560.          LogEntry(buff);
  561.          Error(buff+1);
  562.          }
  563.       }
  564.    }
  565.  
  566. ///
  567.  
  568. /****************************
  569.  * Dateifehler              *
  570.  ****************************
  571.  * I: Fehler-Ort, Dateiname *
  572.  * O: ---                   *
  573.  ****************************/
  574.  
  575. /// "FileError"
  576.  
  577. VOID FileError(STRPTR loc, STRPTR file)
  578.    {
  579.    TEXT buff[LEN_LOGLINE+1];
  580.  
  581.    if (loc && file)
  582.       {
  583.       if (strlen(loc)+strlen(file)+16 <= LEN_LOGLINE)
  584.          sprintf(buff, "1FileError: [%s]: %s", loc, file);
  585.       else if (strlen(loc)+14 <= LEN_LOGLINE)
  586.          sprintf(buff, "1FileError: [%s]", loc);
  587.       else if (strlen(file)+12 <= LEN_LOGLINE)
  588.          sprintf(buff, "1FileError: %s", file);
  589.       else
  590.          sprintf(buff, "1FileError: [...] ...");
  591.       }
  592.    else
  593.       sprintf(buff, "1FileError: ???");
  594.  
  595.    LogEntry(buff);
  596.    Error(buff);
  597.    }
  598.  
  599. ///
  600.  
  601. /********************************
  602.  * Kommandoprozeduren ausführen *
  603.  ********************************
  604.  * I: Dateiname                 *
  605.  * O: Erfolg Ja/Nein            *
  606.  ********************************/
  607.  
  608. /// "Batch"
  609.  
  610. BOOL Batch(STRPTR comfile, UBYTE flag)
  611.    {
  612.    FILE *datei;
  613.    TEXT line[LEN_CMDINPUT+2];
  614.    TEXT dosbuff[LEN_DOSPATH+1];
  615.    UWORD level = KMS_LC->Session.CurrentUser->UserData.Level;
  616.    BOOL keepgoing = TRUE;
  617.  
  618.    if (!strstr(comfile, ".COM"))
  619.       return FALSE;
  620.  
  621.    if (flag & BATCH_SYS)
  622.       strcpy(dosbuff, KMSBase->UserDir);
  623.    else
  624.       {
  625.       strcpy(dosbuff, KMSBase->UserDir);
  626.       strcat(dosbuff, KMS_LC->Session.CurrentUser->UserData.Name);
  627.       strcat(dosbuff, "/");
  628.       }
  629.    strcat(dosbuff, comfile);
  630.    ConvertSpace(dosbuff);
  631.  
  632.    if (datei = fopen(dosbuff, "r"))
  633.       {
  634.       if (flag & BATCH_SYS) /* Level temporaer auf Maximum */
  635.          KMS_LC->Session.CurrentUser->UserData.Level = 255;
  636.  
  637.       while(keepgoing && fgets(line, LEN_CMDINPUT+2, datei))
  638.          {
  639.          if (strlen(line) && line[0] != ';' && line[0] != '\n')
  640.             {
  641.             line[strlen(line)-1] = '\0';
  642.  
  643.             strcpy(KMS_LC->Session.InputBuffer, line);
  644.  
  645.             keepgoing = CmdInterpreter();
  646.             }
  647.          }
  648.  
  649.       fclose(datei);
  650.  
  651.       if (flag & BATCH_SYS) /* Level wieder normal */
  652.          KMS_LC->Session.CurrentUser->UserData.Level = level;
  653.  
  654.       return TRUE;
  655.       }
  656.  
  657.    return FALSE;
  658.    }
  659.  
  660. ///
  661.  
  662. /********************************
  663.  * Kommandoprozeduren editieren *
  664.  ********************************
  665.  * I: Dateiname                 *
  666.  * O: OK/Fehler                 *
  667.  ********************************/
  668.  
  669. /// "BatchEdit"
  670.  
  671. BOOL BatchEdit(STRPTR datei)
  672.    {
  673.    TEXT dosbuff[LEN_DOSPATH+1];
  674.    TEXT outbuff[LEN_PARSEOUT+1];
  675.    TEXT cfgstring[20];
  676.    STRPTR editor;
  677.    TEXT sizebuff[LEN_NUMBER+1];
  678.    LONG quota;
  679.  
  680.    if (!strchr(datei, '/') && !strchr(datei, ':'))
  681.       {
  682.       strcpy(dosbuff, KMSBase->UserDir);
  683.       strcat(dosbuff, KMS_LC->Session.CurrentUser->UserData.Name);
  684.       ConvertSpace(dosbuff);
  685.  
  686.       quota = DirWork(dosbuff, "~(#?.KMS)", 0);
  687.       quota = KMS_LC->Session.CurrentUser->UserData.Quota * 1024L - quota;
  688.       if (quota > 0 && quota < SIZE_QUOTAWARN)
  689.          {
  690.          sprintf(sizebuff, "%ld", quota);
  691.          PPArg = sizebuff;
  692.          SysMsg(QUOTA_WARNING);
  693.          PPArg = NULL;
  694.          }
  695.       else if (quota < 0)
  696.          {
  697.          SysMsg(QUOTA_EXCEEDED);
  698.          return FALSE;
  699.          }
  700.       
  701.       strcat(dosbuff, "/");
  702.       }
  703.    else
  704.       strcpy(dosbuff, "");
  705.  
  706.    strcat(dosbuff, datei);
  707.  
  708.    if (KMS_LC->Device & DEV_CONSOLE)
  709.       strcpy(cfgstring, "KMS.coneditor");
  710.    else
  711.       strcpy(cfgstring, "KMS.remoteeditor");
  712.  
  713.    if ((KMS_LC->Session.CurrentUser->UserData.Flags & UF_SCREEN_ED) && (editor = ReadUMSConfigTags(SysUMSAccount, UMSTAG_CfgName, cfgstring, TAG_DONE)))
  714.       {
  715.       PPArg = dosbuff;
  716.       PPArg2 = datei;
  717.       StdStringParse(editor, outbuff, LEN_PARSEOUT);
  718.       PPArg = NULL;
  719.       PPArg2 = NULL;
  720.  
  721.       FreeUMSConfig(SysUMSAccount, editor);
  722.  
  723.       SystemCall(outbuff);
  724.  
  725.       /* Alle CRs in LFs wandeln */
  726.       
  727.       /*
  728.       if (KMS_LC->Device & DEV_SERIAL)
  729.          {
  730.          FILE *dat;
  731.          STRPTR text;
  732.          struct stat stat_buf;
  733.          WORD error = stat(dosbuff, &stat_buf);
  734.  
  735.          if (error == 0 && (dat = fopen(dosbuff, "r")))
  736.             {
  737.             text = (STRPTR)malloc(stat_buf.st_size+1);
  738.             if (text)
  739.                {
  740.                fread(text, 1, stat_buf.st_size, dat);
  741.                text[stat_buf.st_size] = '\0';
  742.                fclose(dat);
  743.  
  744.                STRPTR pointer = text;
  745.                while(*pointer)
  746.                   {
  747.                   if (*pointer == '\r')
  748.                      *pointer = '\n';
  749.                   pointer++;
  750.                   }
  751.  
  752.                dat = fopen(dosbuff, "w");
  753.                if (dat)
  754.                   fwrite(text, 1, stat_buf.st_size, dat);
  755.  
  756.                free(text);
  757.                }
  758.  
  759.             fclose(dat);
  760.             }
  761.          }
  762.       */
  763.       }
  764.    else
  765.       return LineEditor(dosbuff);
  766.  
  767.    return TRUE;
  768.    }
  769.  
  770. ///
  771.  
  772. /********************************
  773.  * Kommandoprozeduren loeschen  *
  774.  ********************************
  775.  * I: Dateiname                 *
  776.  * O: OK/Fehler                 *
  777.  ********************************/
  778.  
  779. /// "BatchDelete"
  780.  
  781. BOOL BatchDelete(STRPTR datei)
  782.    {
  783.    TEXT dosbuff[LEN_DOSPATH+1];
  784.  
  785.    sprintf(dosbuff, "%s%s/%s",
  786.                     KMSBase->UserDir,
  787.                     KMS_LC->Session.CurrentUser->UserData.Name,
  788.                     datei);
  789.    ConvertSpace(dosbuff);
  790.  
  791.    return DeleteFile(dosbuff);
  792.    }
  793.  
  794. ///
  795.  
  796. /********************************
  797.  * Kommandoprozeduren auflisten *
  798.  ********************************
  799.  * I: ---                       *
  800.  * O: OK/Fehler                 *
  801.  ********************************/
  802.  
  803. /// "BatchDir"
  804.  
  805. BOOL BatchDir(VOID)
  806.    {
  807.    TEXT dosbuff[LEN_DOSPATH+1];
  808.    TEXT buff1[LEN_NUMBER+1];
  809.    TEXT buff2[LEN_NUMBER+1];
  810.    LONG size, frei;
  811.  
  812.    strcpy(dosbuff, KMSBase->UserDir);
  813.    strcat(dosbuff, KMS_LC->Session.CurrentUser->UserData.Name);
  814.    ConvertSpace(dosbuff);
  815.  
  816.    SysMsg(BATCHLST_HEAD);
  817.    KMS_LC->Session.LineCounter = 6;
  818.  
  819.    size = DirWork(dosbuff, NULL, DWF_LIST);
  820.    if (size >= 0)
  821.       {
  822.       frei = KMS_LC->Session.CurrentUser->UserData.Quota * 1024L - size;
  823.       if (frei < 0)
  824.          frei = 0;
  825.  
  826.       sprintf(buff1, "%ld", size);
  827.       sprintf(buff2, "%ld", frei);
  828.       PPArg = buff1;
  829.       PPArg2 = buff2;
  830.       SysMsg(BATCHDIR_FREE);
  831.       PPArg2 = NULL;
  832.       PPArg = NULL;
  833.       }
  834.  
  835.    return TRUE;
  836.    }
  837.  
  838. ///
  839.  
  840. /***************************************
  841.  * Auto-Select-Eintrag aufnehmen       *
  842.  ***************************************
  843.  * I: Flag                             *
  844.  * O: Fehler: FALSE                    *
  845.  ***************************************/
  846.  
  847. /// "AddSelEntry"
  848.  
  849. BOOL AddSelEntry(UWORD flag)
  850.    {
  851.    FILE *datei;
  852.    TEXT dosbuff[LEN_DOSPATH+1];
  853.    TEXT namsubj[LEN_REALNAME+LEN_SUBJECT+1];
  854.    TEXT line[LEN_SELLINE+2];
  855.    TEXT typ;
  856.  
  857.    sprintf(dosbuff, "%s%s/SELECT.KMS",
  858.                     KMSBase->UserDir,
  859.                     KMS_LC->Session.CurrentUser->UserData.Name);
  860.    ConvertSpace(dosbuff);
  861.  
  862.    if (flag & (HSF_CURRFROM|HSF_CURRSUBJ))
  863.       {
  864.       if (!Lastmsg)
  865.          {
  866.          SysMsg(NO_MSG_READ);
  867.          return FALSE;
  868.          }
  869.  
  870.       UMSCurrTags[0].ti_Data = Lastmsg;
  871.  
  872.       if (!ReadUMSMsg(MyUMSAccount, &UMSCurrTags[0]))
  873.          {
  874.          SystemError("AddSelEntry", "ReadUMSMsg");
  875.          return FALSE;
  876.          }
  877.       }
  878.  
  879.    if (flag & HSF_CURRFROM)
  880.       typ = '<';
  881.    else if (flag & HSF_CURRSUBJ)
  882.       typ = '=';
  883.    else
  884.       {
  885.       CmdInput(NULL, PROMPT_HSF_ADDTYPE, "<=", NULL, 1, INF_PROMPT);
  886.       if (Plop || ShutDown)
  887.          {
  888.          if (flag & (HSF_CURRFROM|HSF_CURRSUBJ))
  889.             FreeUMSMsg(MyUMSAccount, Lastmsg);
  890.          return FALSE;
  891.          }
  892.  
  893.       typ = *KMS_LC->Session.InputBuffer;
  894.       }
  895.  
  896.    if (typ)
  897.       {
  898.       if (flag & HSF_CURRFROM)
  899.          {
  900.          if (RFromName)
  901.             strncpy(namsubj, RFromName, LEN_REALNAME);
  902.          else
  903.             *namsubj = '\0';
  904.          namsubj[LEN_REALNAME] = '\0';
  905.          }
  906.       else if (flag & HSF_CURRSUBJ)
  907.          {
  908.          if (RSubject)
  909.             strncpy(namsubj, RSubject, LEN_SUBJECT);
  910.          else
  911.             *namsubj = '\0';
  912.          namsubj[LEN_SUBJECT] = '\0';
  913.          }
  914.       else
  915.          *namsubj = '\0';
  916.  
  917.       if (typ == '<')
  918.          CmdInput(NULL, PROMPT_HSF_ADDNAME, NULL, namsubj, LEN_REALNAME, INF_PROMPT|INF_DEFBUF);
  919.       else
  920.          CmdInput(NULL, PROMPT_HSF_ADDSUBJ, NULL, namsubj, LEN_SUBJECT, INF_PROMPT|INF_DEFBUF);
  921.       if (Plop || ShutDown)
  922.          {
  923.          if (flag & (HSF_CURRFROM|HSF_CURRSUBJ))
  924.             FreeUMSMsg(MyUMSAccount, Lastmsg);
  925.          return FALSE;
  926.          }
  927.  
  928.       if (*KMS_LC->Session.InputBuffer)
  929.          {
  930.          if (typ == '=')
  931.             sprintf(line, "%c %d %s\n", typ, KMS_LC->Session.CurrentArea->AreaData.ID, KMS_LC->Session.InputBuffer);
  932.          else
  933.             sprintf(line, "%c 0 %s\n", typ, KMS_LC->Session.InputBuffer);
  934.  
  935.          if (datei = fopen(dosbuff, "a"))
  936.             {
  937.             fputs(line, datei);
  938.  
  939.             SysMsg(HSF_ENTRY_ADDED);
  940.  
  941.             fclose(datei);
  942.             }
  943.          else
  944.             {
  945.             FileError("AddSelEntry", dosbuff);
  946.             if (flag & (HSF_CURRFROM|HSF_CURRSUBJ))
  947.                FreeUMSMsg(MyUMSAccount, Lastmsg);
  948.             return FALSE;
  949.             }
  950.          }
  951.       }
  952.  
  953.    /* Evt. Message freigeben */
  954.  
  955.    if (flag & (HSF_CURRFROM|HSF_CURRSUBJ))
  956.       FreeUMSMsg(MyUMSAccount, Lastmsg);
  957.  
  958.    return TRUE;
  959.    }
  960.  
  961. ///
  962.  
  963. /***************************************
  964.  * Auto-Select-Eintrag löschen         *
  965.  ***************************************
  966.  * I: ---                              *
  967.  * O: Fehler/Leer: FALSE               *
  968.  ***************************************/
  969.  
  970. /// "DelSelEntry"
  971.  
  972. BOOL DelSelEntry(VOID)
  973.    {
  974.    FILE *datei, *tempdat;
  975.    TEXT dosbuff[LEN_DOSPATH+1];
  976.    TEXT line[LEN_SELLINE+2];
  977.    UWORD num = 0;
  978.  
  979.    sprintf(dosbuff, "%s%s/SELECT.KMS",
  980.                     KMSBase->UserDir,
  981.                     KMS_LC->Session.CurrentUser->UserData.Name);
  982.    ConvertSpace(dosbuff);
  983.  
  984.    if (datei = fopen(dosbuff, "r"))
  985.       {
  986.       UWORD result = CmdInput(NULL, PROMPT_HSF_DELNUM, NULL, NULL, 3, INF_PROMPT|INF_NUMERIC);
  987.       if (Plop || ShutDown)
  988.          {
  989.          fclose(datei);
  990.          return FALSE;
  991.          }
  992.  
  993.       if (result)
  994.          {
  995.          if (tempdat = fopen(KMSTempDat, "w"))
  996.             {
  997.             while(fgets(line, LEN_SELLINE+2, datei))
  998.                {
  999.                if (strlen(line) > 3 && *line != ';' && *line != '\n')
  1000.                   {
  1001.                   num++;
  1002.                   if (num != result)
  1003.                      fputs(line, tempdat);
  1004.                   }
  1005.                else
  1006.                   fputs(line, tempdat);
  1007.                }
  1008.  
  1009.             fclose(tempdat);
  1010.             }
  1011.          else
  1012.             {
  1013.             FileError("DelSelEntry", KMSTempDat);
  1014.             fclose(datei);
  1015.  
  1016.             return FALSE;
  1017.             }
  1018.  
  1019.          fclose(datei);
  1020.  
  1021.          if (tempdat = fopen(KMSTempDat, "r"))
  1022.             {
  1023.             if (datei = fopen(dosbuff, "w"))
  1024.                {
  1025.                while(fgets(line, LEN_SELLINE+2, tempdat))
  1026.                   fputs(line, datei);
  1027.  
  1028.                SysMsg(HSF_ENTRY_DELETED);
  1029.  
  1030.                fclose(datei);
  1031.                }
  1032.             else
  1033.                FileError("DelSelEntry", dosbuff);
  1034.  
  1035.             fclose(tempdat);
  1036.             }
  1037.          else
  1038.             {
  1039.             FileError("DelSelEntry", KMSTempDat);
  1040.  
  1041.             return FALSE;
  1042.             }
  1043.          }
  1044.       else
  1045.          fclose(datei);
  1046.       }
  1047.    else
  1048.       {
  1049.       SysMsg(HSF_NOT_FOUND);
  1050.  
  1051.       return FALSE;
  1052.       }
  1053.  
  1054.    return TRUE;
  1055.    }
  1056.  
  1057. ///
  1058.  
  1059. /***************************************
  1060.  * Auto-Select-Einträge auflisten      *
  1061.  ***************************************
  1062.  * I: ---                              *
  1063.  * O: Fehler/Leer: FALSE               *
  1064.  ***************************************/
  1065.  
  1066. /// "ListSelFile"
  1067.  
  1068. BOOL ListSelFile(VOID)
  1069.    {
  1070.    FILE *datei;
  1071.    TEXT dosbuff[LEN_DOSPATH+1];
  1072.    TEXT namsubj[LEN_REALNAME+LEN_SUBJECT+1];
  1073.    TEXT line[LEN_SELLINE+2];
  1074.    TEXT typ[2];
  1075.    UWORD areaid;
  1076.    UWORD num = 0;
  1077.    ULONG pos;
  1078.  
  1079.    sprintf(dosbuff, "%s%s/SELECT.KMS",
  1080.                     KMSBase->UserDir,
  1081.                     KMS_LC->Session.CurrentUser->UserData.Name);
  1082.    ConvertSpace(dosbuff);
  1083.  
  1084.    if (datei = fopen(dosbuff, "r"))
  1085.       {
  1086.       while(fgets(line, LEN_SELLINE+2, datei))
  1087.          {
  1088.          if (strlen(line) > 3 && line[0] != ';' && line[0] != '\n')
  1089.             {
  1090.             num++;
  1091.  
  1092.             line[strlen(line)-1] = '\0';
  1093.  
  1094.             pos = 0;
  1095.             areaid = 0;
  1096.             *typ = '\0';
  1097.             *namsubj = '\0';
  1098.             sscanf(line, "%s %hd %n", typ, &areaid, &pos);
  1099.             strcpy(namsubj, line+pos);
  1100.  
  1101.             CreatePath(SetArea(areaid));
  1102.             sprintf(line, "%2d %s %-35s %s", num, typ, PathString, namsubj);
  1103.             Print(line, 0);
  1104.             }
  1105.          }
  1106.  
  1107.       fclose(datei);
  1108.       }
  1109.  
  1110.    if (!num)
  1111.       SysMsg(HSF_NOT_FOUND);
  1112.  
  1113.    return (BOOL)num;
  1114.    }
  1115.  
  1116. ///
  1117.  
  1118. /***************************************
  1119.  * Auto-Select-File bearbeiten         *
  1120.  ***************************************
  1121.  * I: Flag                             *
  1122.  * O: Fehler/Leer: FALSE               *
  1123.  ***************************************/
  1124.  
  1125. /// "ExecSelFile"
  1126.  
  1127. BOOL ExecSelFile(UWORD flag)
  1128.    {
  1129.    FILE *datei;
  1130.    TEXT dosbuff[LEN_DOSPATH+1];
  1131.    TEXT namsubj[LEN_REALNAME+LEN_SUBJECT+1];
  1132.    TEXT line[LEN_SELLINE+2];
  1133.    TEXT typ[2];
  1134.    UWORD num = 0;
  1135.    UWORD areaid;
  1136.    ULONG pos;
  1137.  
  1138.    sprintf(dosbuff, "%s%s/SELECT.KMS",
  1139.                     KMSBase->UserDir,
  1140.                     KMS_LC->Session.CurrentUser->UserData.Name);
  1141.    ConvertSpace(dosbuff);
  1142.  
  1143.    SysMsg(PRESELECT_RUNNING);
  1144.    MsgSelect(MS_RESET|MS_QUIET, NULL);
  1145.    MsgSelect(MS_DEFAULT|MS_QUIET, NULL);
  1146.  
  1147.    if (datei = fopen(dosbuff, "r"))
  1148.       {
  1149.       while(fgets(line, LEN_SELLINE+2, datei))
  1150.          {
  1151.          if (strlen(line) > 3 && line[0] != ';' && line[0] != '\n')
  1152.             {
  1153.             num++;
  1154.  
  1155.             line[strlen(line)-1] = '\0';
  1156.  
  1157.             pos = 0;
  1158.             areaid = 0;
  1159.             *typ = '\0';
  1160.             *namsubj = '\0';
  1161.             sscanf(line, "%s %hd %n", typ, &areaid, &pos);
  1162.             strcpy(namsubj, line+pos);
  1163.  
  1164.             if (*namsubj)
  1165.                {
  1166.                switch(*typ)
  1167.                   {
  1168.                   case '<':
  1169.                      MsgSelect(MS_FROM|MS_QUIET, namsubj);
  1170.                      break;
  1171.                   case '=':
  1172.                      struct AreaNode *anode;
  1173.  
  1174.                      TakeASem(FALSE);
  1175.                      if (anode = SetArea(areaid))
  1176.                         {
  1177.                         DropASem();
  1178.  
  1179.                         SelectArea(anode->AreaData.MBName);
  1180.                      
  1181.                         MsgSelect(MS_SUBJECT|MS_QUIET, namsubj);
  1182.  
  1183.                         SelectArea(KMS_LC->Session.CurrentArea->AreaData.MBName);
  1184.                         }
  1185.                      else
  1186.                         {
  1187.                         DropASem();
  1188.                         SysMsg(AREA_NOT_FOUND);
  1189.                         }
  1190.                      break;
  1191.                   default:
  1192.                      break;
  1193.                   }
  1194.                }
  1195.             }
  1196.          }
  1197.  
  1198.       fclose(datei);
  1199.       }
  1200.  
  1201.    LONG result;
  1202.  
  1203.    if (flag & HSF_NEWS)
  1204.       MsgSelect(MS_NEW|MS_QUIET, NULL);
  1205.  
  1206.    if (result = MsgSelect(MS_RESULT|MS_QUIET, NULL))
  1207.       {
  1208.       sprintf(dosbuff, "%ld", result);
  1209.       PPArg = dosbuff;
  1210.       SysMsg(SELECT_RESULT);
  1211.       PPArg = NULL;
  1212.       }
  1213.    else
  1214.       SysMsg(NO_MSG_SELECTED);
  1215.  
  1216.    return (BOOL)num;
  1217.    }
  1218.  
  1219. ///
  1220.  
  1221. /***************************************
  1222.  * Auto-Kill-Eintrag aufnehmen         *
  1223.  ***************************************
  1224.  * I: Flag                             *
  1225.  * O: Fehler: FALSE                    *
  1226.  ***************************************/
  1227.  
  1228. /// "AddKillEntry"
  1229.  
  1230. BOOL AddKillEntry(UWORD flag)
  1231.    {
  1232.    FILE *datei;
  1233.    TEXT dosbuff[LEN_DOSPATH+1];
  1234.    TEXT nasupa[LEN_KMSPATH+1];
  1235.    TEXT line[LEN_KILLINE+2];
  1236.    TEXT typ;
  1237.    struct AreaNode *anode;
  1238.  
  1239.    sprintf(dosbuff, "%s%s/KILL.KMS",
  1240.                     KMSBase->UserDir,
  1241.                     KMS_LC->Session.CurrentUser->UserData.Name);
  1242.    ConvertSpace(dosbuff);
  1243.  
  1244.    if (flag & (HKF_CURRFROM|HKF_CURRSUBJ))
  1245.       {
  1246.       if (!Lastmsg)
  1247.          {
  1248.          SysMsg(NO_MSG_READ);
  1249.          return FALSE;
  1250.          }
  1251.  
  1252.       UMSCurrTags[0].ti_Data = Lastmsg;
  1253.  
  1254.       if (!ReadUMSMsg(MyUMSAccount, &UMSCurrTags[0]))
  1255.          {
  1256.          SystemError("AddKillEntry", "ReadUMSMsg");
  1257.          return FALSE;
  1258.          }
  1259.       }
  1260.  
  1261.    if (flag & HKF_CURRFROM)
  1262.       {
  1263.       if (flag & HKF_GLOBAL)
  1264.          typ = '*';
  1265.       else
  1266.          typ = '<';
  1267.       }
  1268.    else if (flag & HKF_CURRSUBJ)
  1269.       typ = '=';
  1270.    else if (flag & HKF_CURRAREA)
  1271.       typ = '#';
  1272.    else
  1273.       {
  1274.       CmdInput(NULL, PROMPT_HKF_ADDTYPE, "<=#*", NULL, 1, INF_PROMPT);
  1275.       if (Plop || ShutDown)
  1276.          {
  1277.          if (flag & (HKF_CURRFROM|HKF_CURRSUBJ))
  1278.             FreeUMSMsg(MyUMSAccount, Lastmsg);
  1279.          return FALSE;
  1280.          }
  1281.       typ = *KMS_LC->Session.InputBuffer;
  1282.       }
  1283.  
  1284.    if (typ)
  1285.       {
  1286.       if (flag & HKF_CURRFROM)
  1287.          {
  1288.          if (RFromName)
  1289.             strncpy(nasupa, RFromName, LEN_REALNAME);
  1290.          else
  1291.             *nasupa = '\0';
  1292.          nasupa[LEN_REALNAME] = '\0';
  1293.          }
  1294.       else if (flag & HKF_CURRSUBJ)
  1295.          {
  1296.          if (RSubject)
  1297.             strncpy(nasupa, RSubject, LEN_SUBJECT);
  1298.          else
  1299.             *nasupa = '\0';
  1300.          nasupa[LEN_SUBJECT] = '\0';
  1301.          }
  1302.       else if (flag & HKF_CURRAREA)
  1303.          {
  1304.          CreatePath(KMS_LC->Session.CurrentArea);
  1305.          strcpy(nasupa, PathString);
  1306.          }
  1307.       else
  1308.          *nasupa = '\0';
  1309.  
  1310.       if (typ == '#')
  1311.          {
  1312.          if (flag & HKF_CURRAREA)
  1313.             strcpy(PathString, nasupa);
  1314.          else
  1315.             *PathString = '\0';
  1316.          strcpy(KMS_LC->Session.InputBuffer, " ");
  1317.  
  1318.          while(strlen(KMS_LC->Session.InputBuffer) && stricmp(PathString, KMS_LC->Session.InputBuffer))
  1319.             {
  1320.             CmdInput(NULL, PROMPT_HKF_ADDPATH, NULL, PathString, LEN_KMSPATH, INF_PROMPT|INF_UPCASE|INF_DEFBUF);
  1321.             if (Plop || ShutDown)
  1322.                {
  1323.                if (flag & (HSF_CURRFROM|HSF_CURRSUBJ))
  1324.                   FreeUMSMsg(MyUMSAccount, Lastmsg);
  1325.                return FALSE;
  1326.                }
  1327.  
  1328.             if (strlen(KMS_LC->Session.InputBuffer))
  1329.                {
  1330.                if (anode = ChangeArea(KMS_LC->Session.InputBuffer))
  1331.                   if (anode->AreaData.ID != 1)
  1332.                      CreatePath(anode);
  1333.                }
  1334.             }
  1335.          }
  1336.       else if (typ == '<' || typ == '*')
  1337.          CmdInput(NULL, PROMPT_HKF_ADDNAME, NULL, nasupa, LEN_REALNAME, INF_PROMPT|INF_DEFBUF);
  1338.       else
  1339.          CmdInput(NULL, PROMPT_HKF_ADDSUBJ, NULL, nasupa, LEN_SUBJECT, INF_PROMPT|INF_DEFBUF);
  1340.       if (Plop || ShutDown)
  1341.          {
  1342.          if (flag & (HSF_CURRFROM|HSF_CURRSUBJ))
  1343.             FreeUMSMsg(MyUMSAccount, Lastmsg);
  1344.          return FALSE;
  1345.          }
  1346.  
  1347.       if (*KMS_LC->Session.InputBuffer)
  1348.          {
  1349.          if (typ == '#')
  1350.             sprintf(line, "# %d #?\n", anode->AreaData.ID);
  1351.          else if (typ == '*')
  1352.             sprintf(line, "%c 0 %s\n", typ, KMS_LC->Session.InputBuffer);
  1353.          else
  1354.             sprintf(line, "%c %d %s\n", typ, KMS_LC->Session.CurrentArea->AreaData.ID, KMS_LC->Session.InputBuffer);
  1355.  
  1356.          if (datei = fopen(dosbuff, "a"))
  1357.             {
  1358.             fputs(line, datei);
  1359.  
  1360.             SysMsg(HKF_ENTRY_ADDED);
  1361.  
  1362.             fclose(datei);
  1363.             }
  1364.          else
  1365.             {
  1366.             FileError("AddKillEntry", dosbuff);
  1367.             if (flag & (HKF_CURRFROM|HKF_CURRSUBJ))
  1368.                FreeUMSMsg(MyUMSAccount, Lastmsg);
  1369.             return FALSE;
  1370.             }
  1371.          }
  1372.       }
  1373.  
  1374.    /* Evt. Message freigeben */
  1375.  
  1376.    if (flag & (HKF_CURRFROM|HKF_CURRSUBJ))
  1377.       FreeUMSMsg(MyUMSAccount, Lastmsg);
  1378.  
  1379.    return TRUE;
  1380.    }
  1381.  
  1382. ///
  1383.  
  1384. /***************************************
  1385.  * Auto-Kill-Eintrag löschen           *
  1386.  ***************************************
  1387.  * I: ---                              *
  1388.  * O: Fehler/Leer: FALSE               *
  1389.  ***************************************/
  1390.  
  1391. /// "DelKillEntry"
  1392.  
  1393. BOOL DelKillEntry(VOID)
  1394.    {
  1395.    FILE *datei, *tempdat;
  1396.    TEXT dosbuff[LEN_DOSPATH+1];
  1397.    TEXT line[LEN_KILLINE+2];
  1398.    UWORD num = 0;
  1399.  
  1400.    sprintf(dosbuff, "%s%s/KILL.KMS",
  1401.                     KMSBase->UserDir,
  1402.                     KMS_LC->Session.CurrentUser->UserData.Name);
  1403.    ConvertSpace(dosbuff);
  1404.  
  1405.    if (datei = fopen(dosbuff, "r"))
  1406.       {
  1407.       UWORD result = CmdInput(NULL, PROMPT_HKF_DELNUM, NULL, NULL, 3, INF_PROMPT|INF_NUMERIC);
  1408.       if (Plop || ShutDown)
  1409.          {
  1410.          fclose(datei);
  1411.          return FALSE;
  1412.          }
  1413.       if (result)
  1414.          {
  1415.          if (tempdat = fopen(KMSTempDat, "w"))
  1416.             {
  1417.             while(fgets(line, LEN_KILLINE+2, datei))
  1418.                {
  1419.                if (strlen(line) > 3 && line[0] != ';' && line[0] != '\n')
  1420.                   {
  1421.                   num++;
  1422.                   if (num != result)
  1423.                      fputs(line, tempdat);
  1424.                   }
  1425.                else
  1426.                   fputs(line, tempdat);
  1427.                }
  1428.  
  1429.             fclose(tempdat);
  1430.             }
  1431.          else
  1432.             {
  1433.             FileError("DelKillEntry", KMSTempDat);
  1434.             fclose(datei);
  1435.             return FALSE;
  1436.             }
  1437.  
  1438.          fclose(datei);
  1439.  
  1440.          if (tempdat = fopen(KMSTempDat, "r"))
  1441.             {
  1442.             if (datei = fopen(dosbuff, "w"))
  1443.                {
  1444.                while(fgets(line, LEN_KILLINE+2, tempdat))
  1445.                   fputs(line, datei);
  1446.  
  1447.                SysMsg(HKF_ENTRY_DELETED);
  1448.  
  1449.                fclose(datei);
  1450.                }
  1451.             else
  1452.                FileError("DelKillEntry", dosbuff);
  1453.  
  1454.             fclose(tempdat);
  1455.             }
  1456.          else
  1457.             {
  1458.             FileError("DelKillEntry", KMSTempDat);
  1459.             return FALSE;
  1460.             }
  1461.          }
  1462.       else
  1463.          fclose(datei);
  1464.       }
  1465.    else
  1466.       {
  1467.       SysMsg(HKF_NOT_FOUND);
  1468.       return FALSE;
  1469.       }
  1470.  
  1471.    return TRUE;
  1472.    }
  1473.  
  1474. ///
  1475.  
  1476. /***************************************
  1477.  * Auto-Kill-Einträge auflisten        *
  1478.  ***************************************
  1479.  * I: ---                              *
  1480.  * O: Fehler/Leer: FALSE               *
  1481.  ***************************************/
  1482.  
  1483. /// "ListKillFile"
  1484.  
  1485. BOOL ListKillFile(VOID)
  1486.    {
  1487.    FILE *datei;
  1488.    TEXT dosbuff[LEN_DOSPATH+1];
  1489.    TEXT nasupa[LEN_KMSPATH+1];
  1490.    TEXT line[LEN_KILLINE+2];
  1491.    TEXT typ[2];
  1492.    UWORD areaid;
  1493.    UWORD num = 0;
  1494.    ULONG pos;
  1495.  
  1496.    sprintf(dosbuff, "%s%s/KILL.KMS",
  1497.                     KMSBase->UserDir,
  1498.                     KMS_LC->Session.CurrentUser->UserData.Name);
  1499.    ConvertSpace(dosbuff);
  1500.  
  1501.    if (datei = fopen(dosbuff, "r"))
  1502.       {
  1503.       while(fgets(line, LEN_KILLINE+2, datei))
  1504.          {
  1505.          if (strlen(line) > 3 && line[0] != ';' && line[0] != '\n')
  1506.             {
  1507.             num++;
  1508.  
  1509.             line[strlen(line)-1] = '\0';
  1510.  
  1511.             pos = 0;
  1512.             areaid = 0;
  1513.             *typ = '\0';
  1514.             *nasupa = '\0';
  1515.             sscanf(line, "%s %hd %n", typ, &areaid, &pos);
  1516.             strcpy(nasupa, line+pos);
  1517.  
  1518.             if (areaid)
  1519.                CreatePath(SetArea(areaid));
  1520.             else
  1521.                strcpy(PathString, "*");
  1522.             sprintf(line, "%2d %s %-35s %s", num, typ, PathString, nasupa);
  1523.             Print(line, 0);
  1524.             }
  1525.          }
  1526.  
  1527.       fclose(datei);
  1528.       }
  1529.  
  1530.    if (!num)
  1531.       SysMsg(HKF_NOT_FOUND);
  1532.  
  1533.    return (BOOL)num;
  1534.    }
  1535.  
  1536. ///
  1537.  
  1538. /***************************************
  1539.  * Auto-Kill-File bearbeiten           *
  1540.  ***************************************
  1541.  * I: ---                              *
  1542.  * O: Fehler/Leer: FALSE               *
  1543.  ***************************************/
  1544.  
  1545. /// "ExecKillFile"
  1546.  
  1547. BOOL ExecKillFile(VOID)
  1548.    {
  1549.    FILE *datei;
  1550.    TEXT dosbuff[LEN_DOSPATH+1];
  1551.    TEXT nasupa[LEN_KMSPATH+1];
  1552.    TEXT line[LEN_KILLINE+2];
  1553.    TEXT typ[2];
  1554.    UWORD areaid;
  1555.    UWORD num = 0;
  1556.    ULONG sum = 0;
  1557.    ULONG pos;
  1558.  
  1559.    sprintf(dosbuff, "%s%s/KILL.KMS",
  1560.                     KMSBase->UserDir,
  1561.                     KMS_LC->Session.CurrentUser->UserData.Name);
  1562.    ConvertSpace(dosbuff);
  1563.  
  1564.    SysMsg(PREREAD_RUNNING);
  1565.  
  1566.    if (datei = fopen(dosbuff, "r"))
  1567.       {
  1568.       while(fgets(line, LEN_KILLINE+2, datei))
  1569.          {
  1570.          if (strlen(line) > 3 && line[0] != ';' && line[0] != '\n')
  1571.             {
  1572.             num++;
  1573.  
  1574.             line[strlen(line)-1] = '\0';
  1575.  
  1576.             pos = 0;
  1577.             areaid = 0;
  1578.             *typ = '\0';
  1579.             *nasupa = '\0';
  1580.             sscanf(line, "%s %hd %n", typ, &areaid, &pos);
  1581.             strcpy(nasupa, line+pos);
  1582.  
  1583.             if (areaid && *nasupa)
  1584.                {
  1585.                struct AreaNode *anode;
  1586.  
  1587.                TakeASem(FALSE);
  1588.                if (anode = SetArea(areaid))
  1589.                   {
  1590.                   DropASem();
  1591.  
  1592.                   SelectArea(anode->AreaData.MBName);
  1593.  
  1594.                   switch(*typ)
  1595.                      {
  1596.                      case '<':
  1597.                         sum += MarkRead(MR_FROM|MR_QUIET, nasupa);
  1598.                         break;
  1599.                      case '=':
  1600.                         sum += MarkRead(MR_THREAD|MR_QUIET, nasupa);
  1601.                         break;
  1602.                      case '#':
  1603.                         sum += MarkRead(MR_AREA|MR_QUIET, anode->AreaData.MBName);
  1604.                         break;
  1605.                      default:
  1606.                         break;
  1607.                      }
  1608.                   }
  1609.                else
  1610.                   {
  1611.                   DropASem();
  1612.                   SysMsg(AREA_NOT_FOUND);
  1613.                   }
  1614.                }
  1615.             else if (*nasupa)
  1616.                {
  1617.                if (*typ == '*')
  1618.                   sum += MarkRead(MR_FROM|MR_GLOBAL|MR_QUIET, nasupa);
  1619.                }
  1620.             }
  1621.          }
  1622.  
  1623.       SelectArea(KMS_LC->Session.CurrentArea->AreaData.MBName);
  1624.  
  1625.       fclose(datei);
  1626.       }
  1627.  
  1628.    if (sum)
  1629.       {
  1630.       sprintf(line, "%ld", sum);
  1631.       PPArg = line;
  1632.       SysMsg(PREREAD_RESULT);
  1633.       PPArg = NULL;
  1634.       }
  1635.    else
  1636.       SysMsg(NO_MSG_PREREAD);
  1637.  
  1638.    return (BOOL)num;
  1639.    }
  1640.  
  1641. ///
  1642.  
  1643. /***************************************
  1644.  * Alias-Eintrag aufnehmen             *
  1645.  ***************************************
  1646.  * I: Flag                             *
  1647.  * O: Fehler: FALSE                    *
  1648.  ***************************************/
  1649.  
  1650. /// "AddAliasEntry"
  1651.  
  1652. BOOL AddAliasEntry(UWORD flag)
  1653.    {
  1654.    FILE *datei;
  1655.    TEXT dosbuff[LEN_DOSPATH+1];
  1656.    TEXT line[LEN_ALIASLINE+2];
  1657.    TEXT nam[LEN_REALNAME+1];
  1658.    TEXT alias[LEN_ALIAS+1];
  1659.    TEXT adr[LEN_ADDRESS+1];
  1660.  
  1661.    sprintf(dosbuff, "%s%s/ALIAS.KMS",
  1662.                     KMSBase->UserDir,
  1663.                     KMS_LC->Session.CurrentUser->UserData.Name);
  1664.    ConvertSpace(dosbuff);
  1665.  
  1666.    if (flag & GA_CURRENT)
  1667.       {
  1668.       if (!Lastmsg)
  1669.          {
  1670.          SysMsg(NO_MSG_READ);
  1671.          return FALSE;
  1672.          }
  1673.  
  1674.       UMSCurrTags[0].ti_Data = Lastmsg;
  1675.  
  1676.       if (!ReadUMSMsg(MyUMSAccount, &UMSCurrTags[0]))
  1677.          {
  1678.          SystemError("AddAliasEntry", "ReadUMSMsg");
  1679.          return FALSE;
  1680.          }
  1681.       }
  1682.  
  1683.    CmdInput(NULL, PROMPT_GA_ALIAS, NULL, NULL, LEN_ALIAS, INF_PROMPT);
  1684.    if (Plop || ShutDown || !*KMS_LC->Session.InputBuffer)
  1685.       {
  1686.       if (flag & GA_CURRENT)
  1687.          FreeUMSMsg(MyUMSAccount, Lastmsg);
  1688.       return FALSE;
  1689.       }
  1690.    strcpy(alias, KMS_LC->Session.InputBuffer);
  1691.  
  1692.    if (flag & GA_CURRENT)
  1693.       {
  1694.       if (RFromName)
  1695.          strncpy(nam, RFromName, LEN_REALNAME);
  1696.       else
  1697.          *nam = '\0';
  1698.       nam[LEN_REALNAME] = '\0';
  1699.       }
  1700.    else
  1701.       *nam = '\0';
  1702.    CmdInput(NULL, PROMPT_GA_NAME, NULL, nam, LEN_REALNAME, INF_PROMPT|INF_DEFBUF);
  1703.    if (Plop || ShutDown)
  1704.       {
  1705.       if (flag & GA_CURRENT)
  1706.          FreeUMSMsg(MyUMSAccount, Lastmsg);
  1707.       return FALSE;
  1708.       }
  1709.    strcpy(nam, KMS_LC->Session.InputBuffer);
  1710.  
  1711.    if (flag & GA_CURRENT)
  1712.       {
  1713.       if (RFromAddr)
  1714.          strncpy(adr, RFromAddr, LEN_ADDRESS);
  1715.       else
  1716.          *adr = '\0';
  1717.       adr[LEN_ADDRESS] = '\0';
  1718.       }
  1719.    else
  1720.       *adr = '\0';
  1721.    CmdInput(NULL, PROMPT_GA_ADDRESS, NULL, adr, LEN_ADDRESS, INF_PROMPT|INF_DEFBUF);
  1722.    if (Plop || ShutDown)
  1723.       {
  1724.       if (flag & GA_CURRENT)
  1725.          FreeUMSMsg(MyUMSAccount, Lastmsg);
  1726.       return FALSE;
  1727.       }
  1728.  
  1729.    if (!*KMS_LC->Session.InputBuffer)
  1730.       strcpy(KMS_LC->Session.InputBuffer, "-");
  1731.  
  1732.    sprintf(line, "%s %s %s\n", alias, KMS_LC->Session.InputBuffer, nam);
  1733.  
  1734.    /* Evt. Message freigeben */
  1735.  
  1736.    if (flag & GA_CURRENT)
  1737.       FreeUMSMsg(MyUMSAccount, Lastmsg);
  1738.  
  1739.    /* Eintrag in Datei */
  1740.  
  1741.    if (datei = fopen(dosbuff, "a"))
  1742.       {
  1743.       fputs(line, datei);
  1744.  
  1745.       SysMsg(GA_ENTRY_ADDED);
  1746.  
  1747.       fclose(datei);
  1748.       }
  1749.    else
  1750.       {
  1751.       FileError("AddAliasEntry", dosbuff);
  1752.       return FALSE;
  1753.       }
  1754.  
  1755.    return TRUE;
  1756.    }
  1757.  
  1758. ///
  1759.  
  1760. /***************************************
  1761.  * Alias-Eintrag löschen               *
  1762.  ***************************************
  1763.  * I: ---                              *
  1764.  * O: Fehler/Leer: FALSE               *
  1765.  ***************************************/
  1766.  
  1767. /// "DelAliasEntry"
  1768.  
  1769. BOOL DelAliasEntry(VOID)
  1770.    {
  1771.    FILE *datei, *tempdat;
  1772.    TEXT dosbuff[LEN_DOSPATH+1];
  1773.    TEXT line[LEN_ALIASLINE+2];
  1774.    UWORD num = 0;
  1775.    BOOL abort = FALSE;
  1776.  
  1777.    sprintf(dosbuff, "%s%s/ALIAS.KMS",
  1778.                     KMSBase->UserDir,
  1779.                     KMS_LC->Session.CurrentUser->UserData.Name);
  1780.    ConvertSpace(dosbuff);
  1781.  
  1782.    if (datei = fopen(dosbuff, "r"))
  1783.       {
  1784.       UWORD result = CmdInput(NULL, PROMPT_GA_DELNUM, NULL, NULL, 3, INF_PROMPT|INF_NUMERIC);
  1785.       if (Plop || ShutDown)
  1786.          {
  1787.          fclose(datei);
  1788.          return FALSE;
  1789.          }
  1790.  
  1791.       if (result)
  1792.          {
  1793.          if (tempdat = fopen(KMSTempDat, "w"))
  1794.             {
  1795.             while(fgets(line, LEN_ALIASLINE+2, datei))
  1796.                {
  1797.                if (strlen(line) > 3 && *line != ';' && *line != '\n')
  1798.                   {
  1799.                   num++;
  1800.  
  1801.                   if (num != result)
  1802.                      fputs(line, tempdat);
  1803.                   }
  1804.                else
  1805.                   fputs(line, tempdat);
  1806.                }
  1807.  
  1808.             fclose(tempdat);
  1809.             }
  1810.          else
  1811.             {
  1812.             FileError("DelAliasEntry", KMSTempDat);
  1813.             fclose(datei);
  1814.  
  1815.             return FALSE;
  1816.             }
  1817.  
  1818.          fclose(datei);
  1819.  
  1820.          if (tempdat = fopen(KMSTempDat, "r"))
  1821.             {
  1822.             if (datei = fopen(dosbuff, "w"))
  1823.                {
  1824.                while(fgets(line, LEN_ALIASLINE+2, tempdat))
  1825.                   fputs(line, datei);
  1826.  
  1827.                SysMsg(GA_ENTRY_DELETED);
  1828.  
  1829.                fclose(datei);
  1830.                }
  1831.             else
  1832.                FileError("DelAliasEntry", dosbuff);
  1833.  
  1834.             fclose(tempdat);
  1835.             }
  1836.          else
  1837.             {
  1838.             FileError("DelAliasEntry", KMSTempDat);
  1839.  
  1840.             return FALSE;
  1841.             }
  1842.          }
  1843.       else
  1844.          fclose(datei);
  1845.       }
  1846.    else
  1847.       {
  1848.       SysMsg(GA_NOT_FOUND);
  1849.  
  1850.       return FALSE;
  1851.       }
  1852.  
  1853.    return TRUE;
  1854.    }
  1855.  
  1856. ///
  1857.  
  1858. /***************************************
  1859.  * Alias-Einträge auflisten            *
  1860.  ***************************************
  1861.  * I: ---                              *
  1862.  * O: Fehler/Leer: FALSE               *
  1863.  ***************************************/
  1864.  
  1865. /// "ListAliasFile"
  1866.  
  1867. BOOL ListAliasFile(VOID)
  1868.    {
  1869.    FILE *datei;
  1870.    TEXT dosbuff[LEN_DOSPATH+1];
  1871.    TEXT line[LEN_ALIASLINE+2];
  1872.    TEXT nam[LEN_REALNAME+1];
  1873.    TEXT alias[LEN_ALIAS+1];
  1874.    TEXT adr[LEN_ADDRESS+1];
  1875.    UWORD num = 0;
  1876.    ULONG pos;
  1877.    UBYTE stop = 0;
  1878.  
  1879.    sprintf(dosbuff, "%s%s/ALIAS.KMS",
  1880.                     KMSBase->UserDir,
  1881.                     KMS_LC->Session.CurrentUser->UserData.Name);
  1882.    ConvertSpace(dosbuff);
  1883.  
  1884.    if (datei = fopen(dosbuff, "r"))
  1885.       {
  1886.       while(!stop && fgets(line, LEN_ALIASLINE+2, datei))
  1887.          {
  1888.          if (strlen(line) && *line != ';' && *line != '\n')
  1889.             {
  1890.             if (!num)
  1891.                {
  1892.                SysMsg(ALIASLIST_HEAD);
  1893.  
  1894.                KMS_LC->Session.LineCounter = 6;
  1895.                }
  1896.  
  1897.             num++;
  1898.  
  1899.             line[strlen(line)-1] = '\0';
  1900.  
  1901.             pos = 0;
  1902.             *adr = '\0';
  1903.             *alias = '\0';
  1904.             *nam = '\0';
  1905.             sscanf(line, "%s %s %n", alias, adr, &pos);
  1906.             strcpy(nam, line+pos);
  1907.  
  1908.             if (!strcmp(adr, "-"))
  1909.                *adr = '\0';
  1910.  
  1911.             sprintf(line, "%2d %-15s %-30.30s %s\n", num, alias, adr, nam);
  1912.             stop = MsgPrint(line, 0);
  1913.             }
  1914.          }
  1915.  
  1916.       fclose(datei);
  1917.  
  1918.       if (!stop)
  1919.          Print(NULL, 0);
  1920.       }
  1921.  
  1922.    if (!num)
  1923.       SysMsg(GA_NOT_FOUND);
  1924.  
  1925.    return (BOOL)num;
  1926.    }
  1927.  
  1928. ///
  1929.  
  1930. /***************************************
  1931.  * Namen-/Adressen-Eingabe einschl.    *
  1932.  * Alias-Check                         *
  1933.  ***************************************
  1934.  * I: Zielpuffer, Flag, Max. Länge     *
  1935.  * O: ---                              *
  1936.  ***************************************/
  1937.  
  1938. /// "GetAlias"
  1939.  
  1940. VOID GetAlias(STRPTR txtbuff, UWORD flag, UWORD maxlen)
  1941.    {
  1942.    static STRPTR name = NULL;
  1943.    static STRPTR addr = NULL;
  1944.  
  1945.    FILE *datei;
  1946.    TEXT dosbuff[LEN_DOSPATH+1];
  1947.    TEXT line[LEN_ALIASLINE+2];
  1948.  
  1949.    UWORD adrpos, nampos;
  1950.    BOOL ende, abort = FALSE;
  1951.    BOOL vorgabe = FALSE;
  1952.  
  1953.    if (flag & GA_RESET || !txtbuff)
  1954.       {
  1955.       if (name)
  1956.          free(name);
  1957.       if (addr)
  1958.          free(addr);
  1959.  
  1960.       name = NULL;
  1961.       addr = NULL;
  1962.  
  1963.       return;
  1964.       }
  1965.  
  1966.    if (strlen(txtbuff))
  1967.       vorgabe = TRUE;
  1968.  
  1969.    *KMS_LC->Session.InputBuffer = '\0';
  1970.  
  1971.    sprintf(dosbuff, "%s%s/ALIAS.KMS",
  1972.                     KMSBase->UserDir,
  1973.                     KMS_LC->Session.CurrentUser->UserData.Name);
  1974.    ConvertSpace(dosbuff);
  1975.  
  1976.    if (flag & GA_NAME)
  1977.       {
  1978.       while(!abort && !strlen(KMS_LC->Session.InputBuffer))
  1979.          {
  1980.          CmdInput(NULL, PROMPT_TONAME, NULL, txtbuff, LEN_REALNAME, INF_PROMPT|INF_DEFBUF);
  1981.          if (Plop || ShutDown)
  1982.             {
  1983.             *txtbuff = '\0';
  1984.             return;
  1985.             }
  1986.          if (vorgabe)
  1987.             {
  1988.             *txtbuff = '\0';
  1989.             vorgabe = FALSE;
  1990.             }
  1991.  
  1992.          /* Name auf Alias pruefen */
  1993.  
  1994.          if (strlen(KMS_LC->Session.InputBuffer) && strcmp(txtbuff, KMS_LC->Session.InputBuffer) && (datei = fopen(dosbuff, "r")))
  1995.             {
  1996.             ende = FALSE;
  1997.  
  1998.             strcat(KMS_LC->Session.InputBuffer, " "); /* Wegen Alias-Namens-Vergleich */
  1999.  
  2000.             while(!ende && fgets(line, LEN_ALIASLINE+2, datei))
  2001.                {
  2002.                if (strlen(line) > 0 && line[0] != ';' && line[0] != '\n')
  2003.                   {
  2004.                   line[strlen(line)-1] = '\0';
  2005.  
  2006.                   adrpos = nampos = 0;
  2007.                   while(line[adrpos] != '\0' && line[adrpos] != ' ')
  2008.                      adrpos++;
  2009.  
  2010.                   if (line[adrpos])
  2011.                      {
  2012.                      nampos = adrpos + 1;
  2013.                      while(line[nampos] != '\0' && line[nampos] != ' ')
  2014.                         nampos++;
  2015.                      }
  2016.  
  2017.                   if (!strncmp(KMS_LC->Session.InputBuffer, line, adrpos+1))
  2018.                      {
  2019.                      /* Alias gefunden */
  2020.  
  2021.                      adrpos++;
  2022.                      if (addr)
  2023.                         free(addr);
  2024.                      addr = (STRPTR)malloc((size_t)(nampos-adrpos+1));
  2025.                      if (addr) /* Adresse */
  2026.                         {
  2027.                         strncpy(addr, &line[adrpos], nampos-adrpos);
  2028.                         addr[nampos-adrpos] = '\0';
  2029.                         if (!strcmp(addr, "-"))
  2030.                            *addr = '\0';
  2031.                         }
  2032.  
  2033.                      nampos++;
  2034.                      if (name)
  2035.                         free(name);
  2036.                      name = (STRPTR)malloc((size_t)(strlen(line)-nampos+1));
  2037.                      if (name) /* Realname */
  2038.                         {
  2039.                         strncpy(name, &line[nampos], strlen(line)-nampos);
  2040.                         name[strlen(line)-nampos] = '\0';
  2041.                         *KMS_LC->Session.InputBuffer = '\0';
  2042.                         }
  2043.  
  2044.                      ende = TRUE;
  2045.                      }
  2046.                   }
  2047.                }
  2048.  
  2049.             KMS_LC->Session.InputBuffer[strlen(KMS_LC->Session.InputBuffer)-1] = '\0'; /* Space wieder weg */
  2050.  
  2051.             if (!ende) /* Nicht gefunden */
  2052.                {
  2053.                if (name)
  2054.                   free(name);
  2055.                if (addr)
  2056.                   free(addr);
  2057.                name = NULL;
  2058.                addr = NULL;
  2059.  
  2060.                *txtbuff = '\0';
  2061.                }
  2062.  
  2063.             if (name)
  2064.                {
  2065.                strncpy(txtbuff, name, maxlen);
  2066.                txtbuff[maxlen] = '\0';
  2067.                }
  2068.  
  2069.             fclose(datei);
  2070.             }
  2071.          else
  2072.             abort = TRUE;
  2073.          }
  2074.       }
  2075.    else if (flag & GA_ADDRESS)
  2076.       {
  2077.       if (addr)
  2078.          {
  2079.          strncpy(txtbuff, addr, maxlen);
  2080.          txtbuff[maxlen] = '\0';
  2081.          }
  2082.  
  2083.       CmdInput(NULL, PROMPT_TOPATH, NULL, txtbuff, LEN_ADDRESS, INF_PROMPT|INF_DEFBUF);
  2084.       if (Plop || ShutDown)
  2085.          {
  2086.          *txtbuff = '\0';
  2087.          return;
  2088.          }
  2089.  
  2090.       }
  2091.  
  2092.    strncpy(txtbuff, KMS_LC->Session.InputBuffer, maxlen);
  2093.    txtbuff[maxlen] = '\0';
  2094.    }
  2095.  
  2096. ///
  2097.  
  2098. /****************************************
  2099.  * WordWrap                             *
  2100.  ****************************************
  2101.  * I: Quell-String, Zeilenlaenge, Flags *
  2102.  * O: ---                               *
  2103.  ****************************************/
  2104.  
  2105. /// "WordWrap"
  2106.  
  2107. VOID WordWrap(STRPTR source, UWORD maxlen, UWORD flags)
  2108.    {
  2109.    STRPTR tp = source;
  2110.    UWORD pos = 0; /* Pos = "Wieviele Zeichen sind bereits ausgegeben?" */
  2111.  
  2112.    while(*tp)
  2113.       {
  2114.       if (*tp == '\n')
  2115.          pos = 0;
  2116.       else if (*tp == '\14') /* Form Feed */
  2117.          {
  2118.          pos = 0;
  2119.  
  2120.          if (flags & WW_NOFANCY)
  2121.             *tp = '\n';
  2122.          }
  2123.       else if (*tp == '\t')
  2124.          {
  2125.          if ((pos / 8 + 1) * 8 <= maxlen)
  2126.             pos = (pos / 8 + 1) * 8;
  2127.          else
  2128.             {
  2129.             *tp = '\n';
  2130.             pos = 0;
  2131.             }
  2132.          }
  2133.       /*
  2134.       else if ((UBYTE)*tp == 236)
  2135.          *tp = '\1';
  2136.       */
  2137.       else if (pos < maxlen)
  2138.          pos++;
  2139.       else /* Umbrechen */
  2140.          {
  2141.          STRPTR merk = tp;
  2142.  
  2143.          while(tp > source && *tp != ' ' && *tp != '\n' && *tp != '\t' && *tp != '\14')
  2144.             tp--;
  2145.  
  2146.          if (*tp == ' ' || *tp == '\t')
  2147.             {
  2148.             *tp = '\n';
  2149.             pos = 0;
  2150.             }
  2151.          else
  2152.             {
  2153.             tp = merk + 1;
  2154.  
  2155.             while(*tp && *tp != ' ' && *tp != '\n' && *tp != '\t' && *tp != '\14')
  2156.                tp++;
  2157.  
  2158.             if (*tp == ' ' || *tp == '\t')
  2159.                *tp = '\n';
  2160.  
  2161.             pos = 0;
  2162.             }
  2163.          }
  2164.  
  2165.       tp++;
  2166.       }
  2167.    }
  2168.  
  2169. ///
  2170.  
  2171. /****************************************
  2172.  * Primitiv-Zeileneditor                *
  2173.  ****************************************
  2174.  * I: Dateiname                         *
  2175.  * O: Ok/Fehler TRUE/FALSE              *
  2176.  ****************************************/
  2177.  
  2178. /// "LineEditor"
  2179.  
  2180. BOOL LineEditor(STRPTR datei)
  2181.    {
  2182.    BOOL weiter = TRUE;
  2183.    FILE *fd;
  2184.  
  2185.    if (fd = fopen(datei, "w"))
  2186.       {
  2187.       SysMsg(EDITOR_INIT);
  2188.  
  2189.       while(weiter)
  2190.          {
  2191.          CmdInput(NULL, 0, NULL, NULL, LEN_CMDINPUT, 0);
  2192.          if (Plop || ShutDown)
  2193.             {
  2194.             fclose(fd);
  2195.             return FALSE;
  2196.             }
  2197.  
  2198.          if (!strcmp(KMS_LC->Session.InputBuffer, "."))
  2199.             weiter = FALSE;
  2200.          else
  2201.             {
  2202.             fputs(KMS_LC->Session.InputBuffer, fd);
  2203.             fputs("\n", fd);
  2204.             }
  2205.          }
  2206.  
  2207.       fclose(fd);
  2208.  
  2209.       return TRUE;
  2210.       }
  2211.    else
  2212.       return FALSE;
  2213.    }
  2214.  
  2215. ///
  2216.  
  2217. /****************************************
  2218.  * Shell-Kommando                       *
  2219.  ****************************************
  2220.  * I: Kommando                          *
  2221.  * O: Result-Code                       *
  2222.  ****************************************/
  2223.  
  2224. /// "SystemCall"
  2225.  
  2226. LONG SystemCall(STRPTR cmd)
  2227.    {
  2228.    LONG result;
  2229.  
  2230.    /* Konsole in CON: Mode schalten */
  2231.  
  2232.    if (IsInteractive(KMS_LC->InHandle))
  2233.       SetMode(KMS_LC->InHandle, 0);
  2234.    KMS_LC->RawMode = FALSE;
  2235.  
  2236.    CursorOn();
  2237.  
  2238.    result = SystemTags(cmd, SYS_Input, KMS_LC->InHandle, SYS_Output, NULL, TAG_DONE);
  2239.    
  2240.    CursorOff();
  2241.    
  2242.    /* Konsole in RAW: Mode schalten */
  2243.  
  2244.    if (IsInteractive(KMS_LC->InHandle))
  2245.       SetMode(KMS_LC->InHandle, 1);
  2246.    KMS_LC->RawMode = TRUE;
  2247.  
  2248.    /* Eventuelles CTRL-C Signal vernichten */
  2249.  
  2250.    SetSignal(0, SIGBREAKF_CTRL_C);
  2251.  
  2252.    return result;
  2253.    }
  2254.  
  2255. ///
  2256.  
  2257. /****************************************
  2258.  * Copy / Move                          *
  2259.  ****************************************
  2260.  * I: From, To, Move-Flag               *
  2261.  * O: Erfolg TRUE/FALSE                 *
  2262.  ****************************************/
  2263.  
  2264. /// "Copy"
  2265.  
  2266. BOOL Copy(STRPTR frompath, STRPTR topath, BOOL moveflag)
  2267.    {
  2268.    if (!frompath || !topath)
  2269.       return FALSE;
  2270.    
  2271.    FILE *from = fopen(frompath, "r");
  2272.    FILE *to = fopen(topath, "w");
  2273.    STRPTR cpbuff;
  2274.    size_t num;
  2275.    BOOL error = FALSE;
  2276.  
  2277.    cpbuff = malloc(8192);
  2278.    if (!cpbuff)
  2279.       return FALSE;
  2280.  
  2281.    if (from && to)
  2282.       {
  2283.       while(num = fread(cpbuff, 1, 8192, from))
  2284.          fwrite(cpbuff, 1, num, to);
  2285.       }
  2286.    else
  2287.       error = TRUE;
  2288.  
  2289.    if (cpbuff)
  2290.       free(cpbuff);
  2291.    if (from)
  2292.       fclose(from);
  2293.    if (to)
  2294.       fclose(to);
  2295.  
  2296.    if (!error && moveflag)
  2297.       DeleteFile(frompath);
  2298.  
  2299.    return !error;
  2300.    }
  2301.  
  2302. ///
  2303.  
  2304.